// category/index.js
const config = require('../../utils/config')
const api = require('../../utils/api')
const App = getApp()

// 默认分类数据，在API返回401错误时使用
const DEFAULT_CATEGORIES = [
  {
    id: 1,
    name: '手机数码',
    image: '/static/images/category1.png',
    children: [
      { id: 11, name: '手机', image: '/static/images/category2.png' },
      { id: 12, name: '平板', image: '/static/images/category2.png' },
      { id: 13, name: '笔记本', image: '/static/images/category2.png' }
    ]
  },
  {
    id: 2,
    name: '服装鞋包',
    image: '/static/images/category1.png',
    children: [
      { id: 21, name: '女装', image: '/static/images/category2.png' },
      { id: 22, name: '男装', image: '/static/images/category2.png' },
      { id: 23, name: '童装', image: '/static/images/category2.png' }
    ]
  },
  {
    id: 3,
    name: '家居家装',
    image: '/static/images/category1.png',
    children: [
      { id: 31, name: '家具', image: '/static/images/category2.png' },
      { id: 32, name: '家纺', image: '/static/images/category2.png' },
      { id: 33, name: '餐厨', image: '/static/images/category2.png' }
    ]
  },
  {
    id: 4,
    name: '食品生鲜',
    image: '/static/images/category1.png',
    children: [
      { id: 41, name: '水果', image: '/static/images/category2.png' },
      { id: 42, name: '蔬菜', image: '/static/images/category2.png' },
      { id: 43, name: '肉类', image: '/static/images/category2.png' }
    ]
  }
];

// 默认商品数据
const DEFAULT_PRODUCTS = [
  {
    id: 101,
    name: 'iPhone 14 Pro',
    cover: '/static/images/category3.png',
    price: 6999
  },
  {
    id: 102,
    name: '华为 P50 Pro',
    cover: '/static/images/category3.png',
    price: 5999
  },
  {
    id: 103,
    name: '小米 13 Ultra',
    cover: '/static/images/category3.png',
    price: 4999
  }
];

Page({
  data: {
    isLoading: true,
    categories: [],
    currentCategory: {},
    subcategories: [],
    products: [],
    pageNum: 1,
    pageSize: 10,
    totalPages: 1,
    isUsingDefaultData: false
  },
  
  onLoad() {
    this.fetchCategories()
  },
  
  onShow() {
    // 刷新tabbar选中状态
    if (typeof this.getTabBar === 'function' && this.getTabBar()) {
      this.getTabBar().setData({
        selected: 1
      })
    }
  },
  
  // 获取分类列表
  fetchCategories() {
    this.setData({ isLoading: true })
    
    // 构建完整URL，方便调试
    const fullUrl = `${config.API_BASE_URL}${config.API.CATEGORY.LIST}`;
    console.log('请求分类数据, URL:', fullUrl);
    
    // 使用真实API调用，获取分类数据
    api.get(config.API.CATEGORY.LIST)
      .then(res => {
        console.log('获取分类数据成功:', res)
        
        // 有些API会在401时也返回数据，检查是否包含code和message
        const isAuthError = res.code === 401 && (res.message === '未登录' || res.message === '认证失败');
        
        // 如果是未登录错误，使用默认数据
        if (isAuthError) {
          console.log('API要求登录，使用默认分类数据');
          this.handleDefaultCategories();
          return;
        }
        
        // 确保返回的是数组
        let categories = []
        if (res.data && Array.isArray(res.data)) {
          categories = res.data
        } else if (res.data && res.data.list && Array.isArray(res.data.list)) {
          categories = res.data.list
        } else if (res.data && typeof res.data === 'object') {
          // 尝试将对象转为数组
          const objData = res.data
          if (Object.keys(objData).length > 0) {
            categories = Object.keys(objData).map(key => objData[key])
          }
        }
        
        // 确保每个分类都有有效的图片
        categories = categories.map(category => {
          if (!category.image || category.image === '' || category.image.indexOf('http') !== 0) {
            return {
              ...category,
              image: '/static/images/category1.png'
            }
          }
          return category
        })
        
        // 过滤掉没有商品的分类
        this.filterCategoriesWithProducts(categories);
      })
      .catch(err => {
        console.error('获取分类数据失败:', err)
        
        // 使用默认分类数据
        this.handleDefaultCategories();
      })
  },
  
  // 过滤没有商品的分类
  filterCategoriesWithProducts(categories) {
    if (categories.length === 0) {
      console.log('API返回分类数据为空，使用默认分类数据');
      this.handleDefaultCategories();
      return;
    }
    
    let processedCategories = [];
    let promises = [];
    
    // 为每个分类检查是否有商品
    categories.forEach(category => {
      const promise = this.checkCategoryHasProducts(category.id)
        .then(hasProducts => {
          if (hasProducts) {
            processedCategories.push(category);
          }
        });
      promises.push(promise);
    });
    
    // 所有检查完成后更新UI
    Promise.all(promises)
      .then(() => {
        if (processedCategories.length === 0) {
          console.log('所有分类都没有商品，使用默认分类数据');
          this.handleDefaultCategories();
          return;
        }
        
        const firstCategory = processedCategories[0];
        
        this.setData({
          categories: processedCategories,
          currentCategory: firstCategory,
          isLoading: false,
          isUsingDefaultData: false
        });
        
        // 获取第一个分类的子分类和商品
        this.fetchSubcategories(firstCategory.id);
        this.fetchCategoryProducts(firstCategory.id);
      })
      .catch(err => {
        console.error('过滤分类失败:', err);
        this.handleDefaultCategories();
      });
  },
  
  // 检查分类是否有商品
  checkCategoryHasProducts(categoryId) {
    return new Promise((resolve) => {
      // 构建完整URL，方便调试
      const fullUrl = `${config.API_BASE_URL}/miniapp/categories/${categoryId}/products`;
      console.log('检查分类是否有商品, URL:', fullUrl);
      
      api.get(`/miniapp/categories/${categoryId}/products`, { page: 1, pageSize: 1 })
        .then(res => {
          let hasProducts = false;
          
          if (res.code === 401) {
            // 如果未登录，使用默认数据，认为有商品
            hasProducts = true;
          } else if (res.data && res.data.records && res.data.records.length > 0) {
            hasProducts = true;
          } else if (res.data && res.data.data && res.data.data.length > 0) {
            hasProducts = true;
          } else if (Array.isArray(res.data) && res.data.length > 0) {
            hasProducts = true;
          }
          
          resolve(hasProducts);
        })
        .catch(() => {
          // 请求失败时，默认认为有商品
          resolve(true);
        });
    });
  },
  
  // 获取子分类
  fetchSubcategories(categoryId) {
    if (!categoryId) return
    
    // 如果使用默认数据，不需要请求
    if (this.data.isUsingDefaultData) {
      // 从默认分类中查找子分类
      const defaultCategory = DEFAULT_CATEGORIES.find(cat => cat.id === categoryId);
      if (defaultCategory && defaultCategory.children) {
        this.setData({
          subcategories: defaultCategory.children
        });
      }
      return;
    }
    
    // 如果分类信息中已经包含子分类，则直接使用
    const currentCategory = this.data.categories.find(item => item.id === categoryId)
    if (currentCategory && currentCategory.children && currentCategory.children.length > 0) {
      this.setData({
        subcategories: currentCategory.children
      });
      return;
    }
    
    // 显示加载提示
    wx.showLoading({
      title: '加载中...',
      mask: true
    })
    
    // 构建完整URL，方便调试
    const fullUrl = `${config.API_BASE_URL}${config.API.CATEGORY.DETAIL}${categoryId}`;
    console.log('请求子分类数据, URL:', fullUrl);
    
    // 请求子分类数据
    api.get(`${config.API.CATEGORY.DETAIL}${categoryId}`)
      .then(res => {
        console.log('获取子分类数据成功:', res)
        
        // 检查是否是未登录错误
        if (res.code === 401 && (res.message === '未登录' || res.message === '认证失败')) {
          console.log('API要求登录，使用默认子分类数据');
          // 从默认分类数据中查找
          const defaultCategory = DEFAULT_CATEGORIES.find(cat => cat.id === categoryId || cat.id === 1);
          if (defaultCategory && defaultCategory.children) {
            this.setData({
              subcategories: defaultCategory.children,
              isUsingDefaultData: true
            });
          }
          wx.hideLoading();
          return;
        }
        
        let children = []
        
        // 提取子分类数据，处理不同的数据结构
        if (res.data && res.data.children && Array.isArray(res.data.children)) {
          children = res.data.children
        } else if (res.data && Array.isArray(res.data)) {
          children = res.data
        } else if (res.data && typeof res.data === 'object' && Object.keys(res.data).length > 0) {
          // 尝试将对象转为数组
          if (res.data.children && typeof res.data.children === 'object') {
            children = Object.keys(res.data.children).map(key => res.data.children[key])
          } else {
            // 当前对象可能就是子分类列表
            const possibleArray = Object.values(res.data)
            if (possibleArray.length > 0 && possibleArray[0].id && possibleArray[0].name) {
              children = possibleArray
            }
          }
        }
        
        // 确保每个子分类都有有效的图片
        children = children.map(child => {
          if (!child.image || child.image === '' || child.image.indexOf('http') !== 0) {
            return {
              ...child,
              image: '/static/images/category2.png'
            }
          }
          return child
        })
        
        // 更新当前分类信息，包含子分类
        const updatedCategory = {
          ...this.data.currentCategory,
          children: children
        }
        
        // 同时更新 categories 中对应分类的数据
        const updatedCategories = this.data.categories.map(item => {
          if (item.id === categoryId) {
            return updatedCategory
          }
          return item
        })
        
        this.setData({
          currentCategory: updatedCategory,
          categories: updatedCategories,
          subcategories: children,
          isUsingDefaultData: false
        })
        
        wx.hideLoading()
      })
      .catch(err => {
        console.error('获取子分类数据失败:', err)
        wx.hideLoading()
        
        // 使用默认数据
        const defaultCategory = DEFAULT_CATEGORIES.find(cat => cat.id === categoryId || cat.id === 1);
        if (defaultCategory && defaultCategory.children) {
          this.setData({
            subcategories: defaultCategory.children,
            isUsingDefaultData: true
          });
        } else {
          wx.showToast({
            title: '获取子分类失败',
            icon: 'none'
          });
        }
      })
  },
  
  // 获取分类商品
  fetchCategoryProducts(categoryId) {
    if (!categoryId) {
      categoryId = this.data.currentCategory.id
    }
    
    if (!categoryId) return
    
    const { pageNum, pageSize } = this.data
    
    // 如果使用默认数据，直接返回默认商品
    if (this.data.isUsingDefaultData) {
      this.setData({
        products: DEFAULT_PRODUCTS
      });
      return;
    }
    
    wx.showLoading({
      title: '加载中...',
      mask: true
    })
    
    // 构建完整URL，方便调试
    const fullUrl = `${config.API_BASE_URL}/miniapp/categories/${categoryId}/products`;
    console.log('请求分类商品数据, URL:', fullUrl, '参数:', { page: pageNum, pageSize: pageSize });
    
    // 请求分类下的商品数据，使用新的路由格式
    api.get(`/miniapp/categories/${categoryId}/products`, { page: pageNum, pageSize: pageSize })
      .then(res => {
        console.log('获取分类商品成功:', res)
        
        // 检查是否是未登录错误
        if (res.code === 401 && (res.message === '未登录' || res.message === '认证失败')) {
          console.log('API要求登录，使用默认商品数据');
          this.setData({
            products: DEFAULT_PRODUCTS,
            isUsingDefaultData: true
          });
          wx.hideLoading();
          return;
        }
        
        // 确保返回的是数组
        let products = []
        if (res.data && res.data.records && Array.isArray(res.data.records)) {
          products = res.data.records
        } else if (res.data && res.data.data && Array.isArray(res.data.data)) {
          products = res.data.data
        } else if (Array.isArray(res.data)) {
          products = res.data
        } else if (res.data && typeof res.data === 'object') {
          // 尝试将对象转为数组
          const objData = res.data
          if (Object.keys(objData).length > 0) {
            products = Object.keys(objData).map(key => objData[key])
          }
        }
        
        // 如果没有商品数据，显示提示
        if (products.length === 0) {
          this.setData({
            products: [],
            isUsingDefaultData: false
          });
          wx.hideLoading();
          wx.showToast({
            title: '该分类暂无商品',
            icon: 'none'
          });
          return;
        }
        
        // 处理产品数据，确保字段名称一致
        products = products.map(product => {
          const processedProduct = { ...product }
          
          // 确保每个产品都有id字段
          if (!processedProduct.id && processedProduct.productId) {
            processedProduct.id = processedProduct.productId
          }
          
          // 确保每个产品都有cover字段,并且是有效的图片URL
          if (!processedProduct.cover && processedProduct.image) {
            processedProduct.cover = processedProduct.image
          } else if (!processedProduct.cover && processedProduct.coverImage) {
            processedProduct.cover = processedProduct.coverImage
          } else if (!processedProduct.cover && processedProduct.pic_url) {
            processedProduct.cover = processedProduct.pic_url
          }
          
          // 检查cover是否是有效的图片URL
          if (!processedProduct.cover || processedProduct.cover === '' || processedProduct.cover.indexOf('http') !== 0) {
            processedProduct.cover = '/static/images/category3.png'
          }
          
          return processedProduct
        })
        
        // 根据pageNum判断是追加还是替换数据
        let newProducts = products;
        if (pageNum > 1) {
          newProducts = [...this.data.products, ...products];
        }
        
        this.setData({
          products: newProducts,
          totalPages: Math.ceil(res.data.total / pageSize),
          isUsingDefaultData: false
        })
        
        wx.hideLoading()
      })
      .catch(err => {
        console.error('获取分类商品失败:', err)
        wx.hideLoading()
        
        // 使用默认商品数据
        this.setData({
          products: DEFAULT_PRODUCTS,
          isUsingDefaultData: true
        })
        
        wx.showToast({
          title: '加载默认商品数据',
          icon: 'none'
        })
      })
  },
  
  // 点击分类
  onCategoryClick(e) {
    const category = e.currentTarget.dataset.category
    
    if (category && category.id !== this.data.currentCategory.id) {
      this.setData({
        currentCategory: category,
        subcategories: [],
        products: [],
        pageNum: 1
      })
      
      // 获取子分类和商品
      this.fetchSubcategories(category.id)
      this.fetchCategoryProducts(category.id)
    }
  },
  
  // 点击子分类
  onSubcategoryClick(e) {
    const subcategory = e.currentTarget.dataset.subcategory
    
    if (subcategory && subcategory.id) {
      wx.navigateTo({
        url: `/pages/product/list/list?categoryId=${subcategory.id}&categoryName=${encodeURIComponent(subcategory.name)}`
      })
    }
  },
  
  // 点击商品
  onProductClick(e) {
    const product = e.currentTarget.dataset.product
    
    if (product && product.id) {
      wx.navigateTo({
        url: `/pages/product/detail/detail?id=${product.id}`
      })
    }
  },
  
  // 跳转到搜索页
  navigateToSearch() {
    wx.navigateTo({
      url: '/pages/search/index'
    })
  },
  
  // 下拉刷新
  onPullDownRefresh() {
    this.setData({
      pageNum: 1
    })
    
    // 刷新当前分类的商品
    this.fetchCategoryProducts(this.data.currentCategory.id)
    wx.stopPullDownRefresh()
  },
  
  // 到底加载更多
  onReachBottom() {
    const { pageNum, totalPages } = this.data
    
    if (pageNum < totalPages) {
      this.setData({
        pageNum: pageNum + 1
      })
      
      // 加载更多商品
      this.fetchCategoryProducts(this.data.currentCategory.id)
    }
  },
  
  // 处理默认分类数据
  handleDefaultCategories() {
    const categories = DEFAULT_CATEGORIES;
    const firstCategory = categories[0];
    
    this.setData({
      categories: categories,
      currentCategory: firstCategory,
      subcategories: firstCategory.children || [],
      products: DEFAULT_PRODUCTS,
      isLoading: false,
      isUsingDefaultData: true
    });
    
    wx.showToast({
      title: '使用默认分类数据',
      icon: 'none'
    });
  },
  
  // 添加到购物车
  handleAddToCart(e) {
    const item = e.currentTarget.dataset.item;
    console.log('添加商品到购物车:', item);
    
    // 检查是否已登录
    const token = wx.getStorageSync('token');
    if (!token) {
      wx.showModal({
        title: '提示',
        content: '请先登录后再添加商品到购物车',
        confirmText: '去登录',
        success(res) {
          if (res.confirm) {
            wx.navigateTo({
              url: '/pages/login/login'
            });
          }
        }
      });
      return;
    }
    
    // 购物车功能暂未完全实现
    wx.showToast({
      title: '已加入购物车',
      icon: 'success'
    });
  },
}) 